package com.clf.data.redis.core.json.ops.impl;

import com.clf.data.redis.core.json.FastJsonRedisTemplate;
import com.clf.data.redis.core.json.ops.FastJsonSetOperations;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.SetOperations;

import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * ops覆盖类，可提供原先ops没有的方法
 *
 * @author <a href="mailto:zhudelie@zuozh.com">zhudelie</a>
 * @since JDK 1.6
 * create on 2017年3月31日
 * Copyright 2017 ZZJR All Rights Reserved.
 */
public class FastJsonSetOperationsImpl<K, V> extends OperationsAware<K, V> implements FastJsonSetOperations<K, V> {
    private SetOperations<K, V> ops;

    public FastJsonSetOperationsImpl(SetOperations<K, V> ops, FastJsonRedisTemplate<K, V> template) {
        super(template);
        this.ops = ops;
    }

    /**
     * 添加多个值
     */
    @Override
    public Long add(K key, V... values) {
        // TODO Auto-generated method stub
        return ops.add(key, values);
    }

    /**
     * 删除多个值
     */
    @Override
    public Long remove(K key, Object... values) {
        // TODO Auto-generated method stub
        return ops.remove(key, values);
    }

    /**
     * 随机删除并返回一个元素
     */
    @Override
    public V pop(K key) {
        // TODO Auto-generated method stub
        return (V) ops.pop(key);
    }

    @Override
    public List<V> pop(K k, long l) {
        return ops.pop(k, l);
    }

    /**
     * 将 member 元素从 source 集合移动到 destination 集合。
     */
    @Override
    public Boolean move(K key, V value, K destKey) {
        // TODO Auto-generated method stub
        return ops.move(key, value, destKey);
    }

    /**
     * 个数
     */
    @Override
    public Long size(K key) {
        // TODO Auto-generated method stub
        return ops.size(key);
    }

    /**
     * 是否为集合中的一个元素
     */
    @Override
    public Boolean isMember(K key, Object o) {
        // TODO Auto-generated method stub
        return ops.isMember(key, o);
    }

    /**
     * 与给定所有给定key的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
     */
    @Override
    public Set<V> intersect(K key, K otherKey) {
        // TODO Auto-generated method stub
        return ops.intersect(key, otherKey);
    }

    /**
     * 与给定所有给定key的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
     */
    @Override
    public Set<V> intersect(K key, Collection<K> otherKeys) {
        // TODO Auto-generated method stub
        return ops.intersect(key, otherKeys);
    }

    /**
     * 命令将给定集合之间的交集存储在指定的key。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long intersectAndStore(K key, K otherKey, K destKey) {
        // TODO Auto-generated method stub
        return ops.intersectAndStore(key, otherKey, destKey);
    }

    /**
     * 命令将给定集合之间的交集存储在指定的key。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long intersectAndStore(K key, Collection<K> otherKeys, K destKey) {
        // TODO Auto-generated method stub
        return ops.intersectAndStore(key, otherKeys, destKey);
    }

    /**
     * 命令返回给定集合的并集。不存在的集合 key 被视为空集。
     */
    @Override
    public Set<V> union(K key, K otherKey) {
        // TODO Auto-generated method stub
        return ops.union(otherKey, otherKey);
    }

    /**
     * 命令返回给定集合的并集。不存在的集合 key 被视为空集。
     */
    @Override
    public Set<V> union(K key, Collection<K> otherKeys) {
        // TODO Auto-generated method stub
        return ops.union(key, otherKeys);
    }

    /**
     * 命令返回给定集合的并集并储存在指定key中。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long unionAndStore(K key, K otherKey, K destKey) {
        // TODO Auto-generated method stub
        return ops.unionAndStore(key, otherKey, destKey);
    }

    /**
     * 命令返回给定集合的并集并储存在指定key中。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long unionAndStore(K key, Collection<K> otherKeys, K destKey) {
        // TODO Auto-generated method stub
        return ops.unionAndStore(key, otherKeys, destKey);
    }

    /**
     * 命令返回给定集合之间的差集。不存在的集合 key 将视为空集
     */
    @Override
    public Set<V> difference(K key, K otherKey) {
        // TODO Auto-generated method stub
        return ops.difference(key, otherKey);
    }

    /**
     * 命令返回给定集合之间的差集。不存在的集合 key 将视为空集
     */
    @Override
    public Set<V> difference(K key, Collection<K> otherKeys) {
        // TODO Auto-generated method stub
        return ops.difference(key, otherKeys);
    }

    /**
     * 命令返回给定集合之间的差集并存在指定key中。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long differenceAndStore(K key, K otherKey, K destKey) {
        // TODO Auto-generated method stub
        return ops.differenceAndStore(key, otherKey, destKey);
    }

    /**
     * 命令返回给定集合之间的差集并存在指定key中。如果指定的key已经存在，则将其覆盖。
     */
    @Override
    public Long differenceAndStore(K key, Collection<K> otherKeys, K destKey) {
        // TODO Auto-generated method stub
        return ops.differenceAndStore(key, otherKeys, destKey);
    }

    /**
     * 获得所有元素
     */
    @Override
    public Set<V> members(K key) {
        // TODO Auto-generated method stub
        return ops.members(key);
    }

    /**
     * 随意获得一个集合元素
     */
    @Override
    public V randomMember(K key) {
        // TODO Auto-generated method stub
        return (V) ops.randomMember(key);
    }

    /**
     * 随机获取count个不重复的元素
     */
    @Override
    public Set<V> distinctRandomMembers(K key, long count) {
        // TODO Auto-generated method stub
        return ops.distinctRandomMembers(key, count);
    }

    /**
     * 随机获取count个元素
     */
    @Override
    public List<V> randomMembers(K key, long count) {
        // TODO Auto-generated method stub
        return ops.randomMembers(key, count);
    }

    @Override
    public Cursor<V> scan(K key, ScanOptions options) {
        // TODO Auto-generated method stub
        return ops.scan(key, options);
    }


}
